/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2002-2003 Apple Computer, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.

	Contains:	mDNS platform plugin for VxWorks.

	Copyright:  Copyright (C) 2002-2004 Apple Computer, Inc., All Rights Reserved.

	Notes for non-Apple platforms:

		TARGET_NON_APPLE should be defined to 1 to avoid relying on Apple-only header files, macros, or functions.

	To Do:

		- Add support for IPv6 (needs VxWorks IPv6 support).
*/

// Set up the debug library to use the default category (see DebugServicesLite.h for details).

#if( !TARGET_NON_APPLE )
	#define	DEBUG_USE_DEFAULT_CATEGORY		1
#endif

#include	<stdarg.h>
#include	<stddef.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>

#include	<sys/types.h>
#include	<arpa/inet.h>
#include	<fcntl.h>
#include	<netinet/if_ether.h>
#include	<netinet/in.h>
#include	<netinet/ip.h>
#include	<sys/ioctl.h>
#include	<sys/socket.h>
#include	<unistd.h>

#include	"vxWorks.h"
#include	"ifLib.h"
#include	"inetLib.h"
#include	"pipeDrv.h"
#include	"selectLib.h"
#include	"semLib.h"
#include	"sockLib.h"
#include	"sysLib.h"
#include	"taskLib.h"
#include	"tickLib.h"

#include	"config.h"

#if( !TARGET_NON_APPLE )
	#include	"ACP/ACPUtilities.h"
	#include	"Support/DebugServicesLite.h"
	#include	"Support/MiscUtilities.h"
#endif

#include	"mDNSEmbeddedAPI.h"

#include	"mDNSVxWorks.h"

#if 0
#pragma mark == Preprocessor ==
#endif

//===========================================================================================================================
//	Preprocessor
//===========================================================================================================================

#if( !TARGET_NON_APPLE )
	debug_log_new_default_category( mdns );
#endif

#if 0
#pragma mark == Constants ==
#endif

//===========================================================================================================================
//	Constants
//===========================================================================================================================

#define	DEBUG_NAME						"[mDNS] "

#define	kMDNSDefaultName				"My-Device"

#define	kMDNSTaskName					"tMDNS"
#define	kMDNSTaskPriority				102
#define	kMDNSTaskStackSize				49152

#define	kMDNSPipeName					"/pipe/mDNS"
#define	kMDNSPipeMessageQueueSize		32
#define	kMDNSPipeMessageSize			1

#define	kInvalidSocketRef				-1

typedef uint8_t		MDNSPipeCommandCode;
enum
{
	kMDNSPipeCommandCodeInvalid			= 0, 
	kMDNSPipeCommandCodeReschedule 		= 1, 
	kMDNSPipeCommandCodeReconfigure		= 2, 
	kMDNSPipeCommandCodeQuit			= 3
};

#if 0
#pragma mark == Structures ==
#endif

//===========================================================================================================================
//	Structures
//===========================================================================================================================

typedef int		MDNSSocketRef;

struct	MDNSInterfaceItem
{
	MDNSInterfaceItem *			next;
	char						name[ 32 ];
	MDNSSocketRef				multicastSocketRef;
	MDNSSocketRef				sendingSocketRef;
	NetworkInterfaceInfo		hostSet;
	mDNSBool					hostRegistered;
	
	int							sendMulticastCounter;
	int							sendUnicastCounter;
	int							sendErrorCounter;
	
	int							recvCounter;
	int							recvErrorCounter;
	int							recvLoopCounter;
};

#if 0
#pragma mark == Macros ==
#endif

//===========================================================================================================================
//	Macros
//===========================================================================================================================

#if( TARGET_NON_APPLE )
	
	// Do-nothing versions of the debugging macros for non-Apple platforms.
	
	#define check(assertion)
	#define check_string( assertion, cstring )
	#define check_noerr(err)
	#define check_noerr_string( error, cstring )
	#define	check_errno( assertion, errno_value )
	#define debug_string( cstring )
	#define require( assertion, label )                             		do { if( !(assertion) ) goto label; } while(0)
	#define require_string( assertion, label, string )						require(assertion, label)
	#define require_quiet( assertion, label )								require( assertion, label )
	#define require_noerr( error, label )									do { if( (error) != 0 ) goto label; } while(0)
	#define require_noerr_quiet( assertion, label )							require_noerr( assertion, label )
	#define require_noerr_action( error, label, action )					do { if( (error) != 0 ) { {action;}; goto label; } } while(0)
	#define require_noerr_action_quiet( assertion, label, action )			require_noerr_action( assertion, label, action )
	#define require_action( assertion, label, action )						do { if( !(assertion) ) { {action;}; goto label; } } while(0)
	#define require_action_quiet( assertion, label, action )				require_action( assertion, label, action )
	#define require_action_string( assertion, label, action, cstring )		do { if( !(assertion) ) { {action;}; goto label; } } while(0)
	#define	require_errno( assertion, errno_value, label )					do { if( !(assertion) ) goto label; } while(0)
	#define	require_errno_action( assertion, errno_value, label, action )	do { if( !(assertion) ) { {action;}; goto label; } } while(0)
	
	#define	dlog( ARGS... )
	
	#define	DEBUG_UNUSED( X )			(void)( X )
#endif

#if 0
#pragma mark == Prototypes ==
#endif

//===========================================================================================================================
//	Prototypes
//===========================================================================================================================

// ifIndexToIfp is in net/if.c, but not exported by net/if.h so provide it here.

extern struct ifnet * ifIndexToIfp(int ifIndex);

// Platform Internals

mDNSlocal void		SetupNames( mDNS * const inMDNS );
mDNSlocal mStatus	SetupInterfaceList( mDNS * const inMDNS );
mDNSlocal mStatus	TearDownInterfaceList( mDNS * const inMDNS );
mDNSlocal mStatus	SetupInterface( mDNS * const inMDNS, const struct ifaddrs *inAddr, MDNSInterfaceItem **outItem );
mDNSlocal mStatus	TearDownInterface( mDNS * const inMDNS, MDNSInterfaceItem *inItem );
mDNSlocal mStatus
	SetupSocket( 
		mDNS * const 			inMDNS, 
		const struct ifaddrs *	inAddr, 
		mDNSIPPort 				inPort, 
		MDNSSocketRef *			outSocketRef );

// Commands

mDNSlocal mStatus	SetupCommandPipe( mDNS * const inMDNS );
mDNSlocal mStatus	TearDownCommandPipe( mDNS * const inMDNS );
mDNSlocal mStatus	SendCommand( const mDNS * const inMDNS, MDNSPipeCommandCode inCommandCode );
mDNSlocal mStatus	ProcessCommand( mDNS * const inMDNS );
mDNSlocal void		ProcessCommandReconfigure( mDNS *inMDNS );

// Threads

mDNSlocal mStatus	SetupTask( mDNS * const inMDNS );
mDNSlocal mStatus	TearDownTask( mDNS * const inMDNS );
mDNSlocal void		Task( mDNS *inMDNS );
mDNSlocal mStatus	TaskInit( mDNS *inMDNS );
mDNSlocal void		TaskSetupReadSet( mDNS *inMDNS, fd_set *outReadSet, int *outMaxSocket );
mDNSlocal void		TaskSetupTimeout( mDNS *inMDNS, mDNSs32 inNextTaskTime, struct timeval *outTimeout );
mDNSlocal void		TaskProcessPacket( mDNS *inMDNS, MDNSInterfaceItem *inItem, MDNSSocketRef inSocketRef );

// Utilities

#if( TARGET_NON_APPLE )
	mDNSlocal void	GenerateUniqueHostName( char *outName, long *ioSeed );
	mDNSlocal void	GenerateUniqueDNSName( char *outName, long *ioSeed );
#endif

// Platform Accessors

#ifdef	__cplusplus
	extern "C" {
#endif

typedef struct mDNSPlatformInterfaceInfo	mDNSPlatformInterfaceInfo;
struct	mDNSPlatformInterfaceInfo
{
	const char *		name;
	mDNSAddr			ip;
};

mDNSexport mStatus	mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID );
mDNSexport mStatus	mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo );

#ifdef	__cplusplus
	}
#endif

#if 0
#pragma mark == Globals ==
#endif

//===========================================================================================================================
//	Globals
//===========================================================================================================================

mDNSlocal mDNS *					gMDNSPtr							= NULL;
mDNSlocal mDNS_PlatformSupport		gMDNSPlatformSupport;
mDNSlocal mDNSs32					gMDNSTicksToMicrosecondsMultiplier	= 0;

// Platform support

mDNSs32								mDNSPlatformOneSecond;

#if 0
#pragma mark -
#pragma mark == Public APIs ==
#endif

//===========================================================================================================================
//	mDNSReconfigure
//===========================================================================================================================

void	mDNSReconfigure( void )
{
	// Send a "reconfigure" command to the MDNS task.
	
	if( gMDNSPtr )
	{
		SendCommand( gMDNSPtr, kMDNSPipeCommandCodeReconfigure );
	}
}

#if 0
#pragma mark -
#pragma mark == Platform Support ==
#endif

//===========================================================================================================================
//	mDNSPlatformInit
//===========================================================================================================================

mStatus	mDNSPlatformInit( mDNS * const inMDNS )
{
	mStatus		err;
	
	dlog( kDebugLevelInfo, DEBUG_NAME "platform init\n" );
	
	// Initialize variables.

	mDNSPlatformMemZero( &gMDNSPlatformSupport, sizeof( gMDNSPlatformSupport ) );
	inMDNS->p							= &gMDNSPlatformSupport;
	inMDNS->p->commandPipe				= ERROR;
	inMDNS->p->task						= ERROR;
	inMDNS->p->rescheduled 				= 1;		// Default to rescheduled until fully initialized.
	mDNSPlatformOneSecond 				= sysClkRateGet();
	gMDNSTicksToMicrosecondsMultiplier	= ( 1000000L / mDNSPlatformOneSecond );
	
	// Allocate semaphores.
	
	inMDNS->p->lockID = semMCreate( SEM_Q_FIFO );
	require_action( inMDNS->p->lockID, exit, err = mStatus_NoMemoryErr );
	
	inMDNS->p->readyEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY );
	require_action( inMDNS->p->readyEvent, exit, err = mStatus_NoMemoryErr );
	
	inMDNS->p->quitEvent = semBCreate( SEM_Q_FIFO, SEM_EMPTY );
	require_action( inMDNS->p->quitEvent, exit, err = mStatus_NoMemoryErr );
	
	gMDNSPtr = inMDNS;
	
	// Set up the task and wait for it to initialize. Initialization is done from the task instead of here to avoid 
	// stack space issues. Some of the initialization may require a larger stack than the current task supports.
	
	err = SetupTask( inMDNS );
	require_noerr( err, exit );
	
	err = semTake( inMDNS->p->readyEvent, WAIT_FOREVER );
	require_noerr( err, exit );
	err = inMDNS->p->taskInitErr;
	require_noerr( err, exit );
	
	mDNSCoreInitComplete( inMDNS, err );
	
exit:
	if( err )
	{
		mDNSPlatformClose( inMDNS );
	}
	dlog( kDebugLevelInfo, DEBUG_NAME "platform init done (err=%ld)\n", err );
	return( err );
}

//===========================================================================================================================
//	mDNSPlatformClose
//===========================================================================================================================

void	mDNSPlatformClose( mDNS * const inMDNS )
{
	mStatus		err;
	
	dlog( kDebugLevelInfo, DEBUG_NAME "platform close\n" );
	check( inMDNS );
	
	// Tear everything down.
	
	err = TearDownTask( inMDNS );
	check_noerr( err );
	
	err = TearDownInterfaceList( inMDNS );
	check_noerr( err );
		
	err = TearDownCommandPipe( inMDNS );
	check_noerr( err );
	
	gMDNSPtr = NULL;
	
	// Release semaphores.
	
	if( inMDNS->p->quitEvent )
	{
		semDelete( inMDNS->p->quitEvent );
		inMDNS->p->quitEvent = 0;
	}
	if( inMDNS->p->readyEvent )
	{
		semDelete( inMDNS->p->readyEvent );
		inMDNS->p->readyEvent = 0;
	}
	if( inMDNS->p->lockID )
	{
		semDelete( inMDNS->p->lockID );
		inMDNS->p->lockID = 0;
	}
	
	dlog( kDebugLevelInfo, DEBUG_NAME "platform close done\n" );
}

//===========================================================================================================================
//	mDNSPlatformSendUDP
//===========================================================================================================================

mStatus
	mDNSPlatformSendUDP( 
		const mDNS * const			inMDNS, 
		const void * const	        inMsg, 
		const mDNSu8 * const		inMsgEnd, 
		mDNSInterfaceID 			inInterfaceID, 
		const mDNSAddr *			inDstIP, 
		mDNSIPPort 					inDstPort )
{
	mStatus					err;
	MDNSInterfaceItem *		item;
	struct sockaddr_in		addr;
	int						n;
	
	dlog( kDebugLevelChatty, DEBUG_NAME "platform send UDP\n" );
	
	// Check parameters.
	
	check( inMDNS );
	check( inMsg );
	check( inMsgEnd );
	check( inInterfaceID );
	check( inDstIP );
	if( inDstIP->type != mDNSAddrType_IPv4 )
	{
		err = mStatus_BadParamErr;
		goto exit;
	}

#if( DEBUG )
	// Make sure the InterfaceID is valid.
	
	for( item = inMDNS->p->interfaceList; item; item = item->next )
	{
		if( item == (MDNSInterfaceItem *) inInterfaceID )
		{
			break;
		}
	}
	require_action( item, exit, err = mStatus_NoSuchNameErr );
#endif

	// Send the packet.
	
	item = (MDNSInterfaceItem *) inInterfaceID;
	check( item->sendingSocketRef != kInvalidSocketRef );
	
	mDNSPlatformMemZero( &addr, sizeof( addr ) );
	addr.sin_family 		= AF_INET;
	addr.sin_port 			= inDstPort.NotAnInteger;
	addr.sin_addr.s_addr 	= inDstIP->ip.v4.NotAnInteger;
	
	n = inMsgEnd - ( (const mDNSu8 * const) inMsg );
	n = sendto( item->sendingSocketRef, (char *) inMsg, n, 0, (struct sockaddr *) &addr, sizeof( addr ) );
	check_errno( n, errno );
	
	item->sendErrorCounter 		+= ( n < 0 );
	item->sendMulticastCounter 	+= ( inDstPort.NotAnInteger == MulticastDNSPort.NotAnInteger );
	item->sendUnicastCounter 	+= ( inDstPort.NotAnInteger != MulticastDNSPort.NotAnInteger );
	
	dlog( kDebugLevelChatty, DEBUG_NAME "sent (to=%u.%u.%u.%u:%hu)\n", 
		  inDstIP->ip.v4.b[ 0 ], inDstIP->ip.v4.b[ 1 ], inDstIP->ip.v4.b[ 2 ], inDstIP->ip.v4.b[ 3 ], 
		  htons( inDstPort.NotAnInteger ) );
	err = mStatus_NoError;

exit:
	dlog( kDebugLevelChatty, DEBUG_NAME "platform send UDP done\n" );
	return( err );
}

//===========================================================================================================================
//	Connection-oriented (TCP) functions
//===========================================================================================================================

mDNSexport mStatus mDNSPlatformTCPConnect(const mDNSAddr *dst, mDNSOpaque16 dstport, mDNSInterfaceID InterfaceID,
										  TCPConnectionCallback callback, void *context, int *descriptor)
	{
	(void)dst;			// Unused
	(void)dstport;		// Unused
	(void)InterfaceID;	// Unused
	(void)callback;		// Unused
	(void)context;		// Unused
	(void)descriptor;	// Unused
	return(mStatus_UnsupportedErr);
	}

mDNSexport void mDNSPlatformTCPCloseConnection(int sd)
	{
	(void)sd;			// Unused
	}

mDNSexport long mDNSPlatformReadTCP(int sd, void *buf, unsigned long buflen)
	{
	(void)sd;			// Unused
	(void)buf;			// Unused
	(void)buflen;			// Unused
	return(0);
	}

mDNSexport long mDNSPlatformWriteTCP(int sd, const char *msg, unsigned long len)
	{
	(void)sd;			// Unused
	(void)msg;			// Unused
	(void)len;			// Unused
	return(0);
	}

//===========================================================================================================================
//	mDNSPlatformLock
//===========================================================================================================================

void	mDNSPlatformLock( const mDNS * const inMDNS )
{
	check( inMDNS->p->lockID );
	
	if( inMDNS->p->lockID )
	{
		#if( TARGET_NON_APPLE )
			semTake( inMDNS->p->lockID, WAIT_FOREVER );
		#else
			semTakeDeadlockDetect( inMDNS->p->lockID, WAIT_FOREVER );
		#endif
	}
}

//===========================================================================================================================
//	mDNSPlatformUnlock
//===========================================================================================================================

void	mDNSPlatformUnlock( const mDNS * const inMDNS )
{
	check( inMDNS );
	check( inMDNS->p );
	check( inMDNS->p->lockID );
	check_string( inMDNS->p->task != ERROR, "mDNS task not started" );
	
	// When an API routine is called, "m->NextScheduledEvent" is reset to "timenow" before calling mDNSPlatformUnlock()
	// Since our main mDNS_Execute() loop is on a different thread, we need to wake up that thread to:
	// (a) handle immediate work (if any) resulting from this API call
	// (b) calculate the next sleep time between now and the next interesting event
	
	if( ( mDNS_TimeNow(inMDNS) - inMDNS->NextScheduledEvent ) >= 0 )
	{
		// We only need to send the reschedule event when called from a task other than the mDNS task since if we are 
		// called from mDNS task, we'll loop back and call mDNS_Execute. This avoids filling up the command queue.
		
		if( ( inMDNS->p->rescheduled++ == 0 ) && ( taskIdSelf() != inMDNS->p->task ) )
		{
			SendCommand( inMDNS, kMDNSPipeCommandCodeReschedule );
		}
	}
	
	if( inMDNS->p->lockID )
	{
		semGive( inMDNS->p->lockID );
	}
}

//===========================================================================================================================
//	mDNSPlatformStrLen
//===========================================================================================================================

mDNSu32  mDNSPlatformStrLen( const void *inSrc )
{
	check( inSrc );
	
	return( (mDNSu32) strlen( (const char *) inSrc ) );
}

//===========================================================================================================================
//	mDNSPlatformStrCopy
//===========================================================================================================================

void	mDNSPlatformStrCopy( void *inDst, const void *inSrc )
{
	check( inSrc );
	check( inDst );
	
	strcpy( (char *) inDst, (const char*) inSrc );
}

//===========================================================================================================================
//	mDNSPlatformMemCopy
//===========================================================================================================================

void	mDNSPlatformMemCopy( void *inDst, const void *inSrc, mDNSu32 inSize )
{
	check( inSrc );
	check( inDst );
	
	memcpy( inDst, inSrc, inSize );
}

//===========================================================================================================================
//	mDNSPlatformMemSame
//===========================================================================================================================

mDNSBool	mDNSPlatformMemSame( const void *inDst, const void *inSrc, mDNSu32 inSize )
{
	check( inSrc );
	check( inDst );
	
	return( memcmp( inSrc, inDst, inSize ) == 0 );
}

//===========================================================================================================================
//	mDNSPlatformMemZero
//===========================================================================================================================

void	mDNSPlatformMemZero( void *inDst, mDNSu32 inSize )
{
	check( inDst );
	
	memset( inDst, 0, inSize );
}

//===========================================================================================================================
//	mDNSPlatformMemAllocate
//===========================================================================================================================

mDNSexport void *	mDNSPlatformMemAllocate( mDNSu32 inSize )
{
	void *		mem;
	
	check( inSize > 0 );
	
	mem = malloc( inSize );
	check( mem );
	
	return( mem );
}

//===========================================================================================================================
//	mDNSPlatformMemFree
//===========================================================================================================================

mDNSexport void	mDNSPlatformMemFree( void *inMem )
{
	check( inMem );
	
	free( inMem );
}

//===========================================================================================================================
//	mDNSPlatformRandomSeed
//===========================================================================================================================

mDNSexport mDNSu32 mDNSPlatformRandomSeed(void)
{
	return( tickGet() );
}

//===========================================================================================================================
//	mDNSPlatformTimeInit
//===========================================================================================================================

mDNSexport mStatus mDNSPlatformTimeInit( void )
{
	// No special setup is required on VxWorks -- we just use tickGet().
	return( mStatus_NoError );
}

//===========================================================================================================================
//	mDNSPlatformRawTime
//===========================================================================================================================

mDNSs32	mDNSPlatformRawTime( void )
{
	return( (mDNSs32) tickGet() );
}

//===========================================================================================================================
//	mDNSPlatformUTC
//===========================================================================================================================

mDNSexport mDNSs32	mDNSPlatformUTC( void )
{
	return( -1 );
}

//===========================================================================================================================
//	mDNSPlatformInterfaceNameToID
//===========================================================================================================================

mStatus	mDNSPlatformInterfaceNameToID( mDNS * const inMDNS, const char *inName, mDNSInterfaceID *outID )
{
	mStatus					err;
	MDNSInterfaceItem *		ifd;
	
	check( inMDNS );
	check( inMDNS->p );
	check( inName );
	
	// Search for an interface with the specified name,
	
	for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next )
	{
		if( strcmp( ifd->name, inName ) == 0 )
		{
			break;
		}
	}
	if( !ifd )
	{
		err = mStatus_NoSuchNameErr;
		goto exit;
	}
		
	// Success!
	
	if( outID )
	{
		*outID = (mDNSInterfaceID) ifd;
	}
	err = mStatus_NoError;
	
exit:
	return( err );
}

//===========================================================================================================================
//	mDNSPlatformInterfaceIDToInfo
//===========================================================================================================================

mStatus	mDNSPlatformInterfaceIDToInfo( mDNS * const inMDNS, mDNSInterfaceID inID, mDNSPlatformInterfaceInfo *outInfo )
{
	mStatus					err;
	MDNSInterfaceItem *		ifd;
	
	check( inMDNS );
	check( inID );
	check( outInfo );
	
	// Search for an interface with the specified ID,
	
	for( ifd = inMDNS->p->interfaceList; ifd; ifd = ifd->next )
	{
		if( ifd == (MDNSInterfaceItem *) inID )
		{
			break;
		}
	}
	if( !ifd )
	{
		err = mStatus_NoSuchNameErr;
		goto exit;
	}
	
	// Success!
	
	outInfo->name 	= ifd->name;
	outInfo->ip 	= ifd->hostSet.ip;
	err 			= mStatus_NoError;
	
exit:
	return( err );
}

//===========================================================================================================================
//	debugf_
//===========================================================================================================================

#if( MDNS_DEBUGMSGS )
mDNSexport void debugf_( const char *format, ... )
{
	char		buffer[ 512 ];
    va_list		args;
    mDNSu32		length;
    
	va_start( args, format );
	length = mDNS_vsnprintf( buffer, sizeof( buffer ), format, args );
	va_end( args );

	dlog( kDebugLevelInfo, "%s\n", buffer );
}
#endif

//===========================================================================================================================
//	verbosedebugf_
//===========================================================================================================================

#if( MDNS_DEBUGMSGS > 1 )
mDNSexport void verbosedebugf_( const char *format, ... )
{
	char		buffer[ 512 ];
    va_list		args;
    mDNSu32		length;
    
	va_start( args, format );
	length = mDNS_vsnprintf( buffer, sizeof( buffer ), format, args );
	va_end( args );
	
	dlog( kDebugLevelVerbose, "%s\n", buffer );
}
#endif

//===========================================================================================================================
//	LogMsg
//===========================================================================================================================

void LogMsg( const char *inFormat, ... )
{
	char		buffer[ 512 ];
    va_list		args;
    mDNSu32		length;
	
	va_start( args, inFormat );
	length = mDNS_vsnprintf( buffer, sizeof( buffer ), inFormat, args );
	va_end( args );
	
	dlog( kDebugLevelWarning, "%s\n", buffer );
}

#if 0
#pragma mark -
#pragma mark == Platform Internals ==
#endif

//===========================================================================================================================
//	SetupNames
//===========================================================================================================================

mDNSlocal void	SetupNames( mDNS * const inMDNS )
{
	char			tempCString[ 128 ];
	mDNSu8			tempPString[ 128 ];
	mDNSu8 *		namePtr;
	
	// Set up the host name.
	
	tempCString[ 0 ] = '\0';
	GenerateUniqueHostName( tempCString, NULL );
	check( tempCString[ 0 ] != '\0' );
	if( tempCString[ 0 ] == '\0' )
	{
		// No name so use the default.
		
		strcpy( tempCString, kMDNSDefaultName );
	}
	inMDNS->nicelabel.c[ 0 ] = strlen( tempCString );
	memcpy( &inMDNS->nicelabel.c[ 1 ], tempCString, inMDNS->nicelabel.c[ 0 ] );
	check( inMDNS->nicelabel.c[ 0 ] > 0 );
	
	// Set up the DNS name.
	
	tempCString[ 0 ] = '\0';
	GenerateUniqueDNSName( tempCString, NULL );
	if( tempCString[ 0 ] != '\0' )
	{
		tempPString[ 0 ] = strlen( tempCString );
		memcpy( &tempPString[ 1 ], tempCString, tempPString[ 0 ] );
		namePtr = tempPString;
	}
	else
	{
		// No DNS name so use the host name.
		
		namePtr = inMDNS->nicelabel.c;
	}
	ConvertUTF8PstringToRFC1034HostLabel( namePtr, &inMDNS->hostlabel );
	if( inMDNS->hostlabel.c[ 0 ] == 0 )
	{
		// Nice name has no characters that are representable as an RFC 1034 name (e.g. Japanese) so use the default.
		
		MakeDomainLabelFromLiteralString( &inMDNS->hostlabel, kMDNSDefaultName );
	}
	check( inMDNS->hostlabel.c[ 0 ] > 0 );

	mDNS_SetFQDN( inMDNS );
	
	dlog( kDebugLevelInfo, DEBUG_NAME "nice name \"%.*s\"\n", inMDNS->nicelabel.c[ 0 ], &inMDNS->nicelabel.c[ 1 ] );
	dlog( kDebugLevelInfo, DEBUG_NAME "host name \"%.*s\"\n", inMDNS->hostlabel.c[ 0 ], &inMDNS->hostlabel.c[ 1 ] );
}

//===========================================================================================================================
//	SetupInterfaceList
//===========================================================================================================================

mDNSlocal mStatus	SetupInterfaceList( mDNS * const inMDNS )
{
	mStatus						err;
	struct ifaddrs *			addrs;
	struct ifaddrs *			p;
	uint32_t					flagMask;
	uint32_t					flagTest;
	MDNSInterfaceItem **		next;
	MDNSInterfaceItem *			item;
	
	addrs = NULL;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface list\n" );
	check( inMDNS );
	
	// Tear down any existing interfaces that may be set up.
	
	TearDownInterfaceList( inMDNS );
	inMDNS->p->interfaceList = NULL;
	next = &inMDNS->p->interfaceList;
	
	// Set up each interface that is active, multicast-capable, and not the loopback interface or point-to-point.
	
	flagMask = IFF_UP | IFF_MULTICAST | IFF_LOOPBACK | IFF_POINTOPOINT;
	flagTest = IFF_UP | IFF_MULTICAST;
	
	err = getifaddrs( &addrs );
	require_noerr( err, exit );
	
	for( p = addrs; p; p = p->ifa_next )
	{
		if( ( p->ifa_flags & flagMask ) == flagTest )
		{
			err = SetupInterface( inMDNS, p, &item );
			require_noerr( err, exit );
			
			*next = item;
			next = &item->next;
		}
	}
	err = mStatus_NoError;
	
exit:
	if( addrs )
	{
		freeifaddrs( addrs );
	}
	if( err )
	{
		TearDownInterfaceList( inMDNS );
	}
	dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface list done (err=%ld)\n", err );
	return( err );
}

//===========================================================================================================================
//	TearDownInterfaceList
//===========================================================================================================================

mDNSlocal mStatus	TearDownInterfaceList( mDNS * const inMDNS )
{
	dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down interface list\n" );
	check( inMDNS );
	
	// Tear down all the interfaces.
	
	while( inMDNS->p->interfaceList )
	{
		MDNSInterfaceItem *		item;
		
		item = inMDNS->p->interfaceList;
		inMDNS->p->interfaceList = item->next;
		
		TearDownInterface( inMDNS, item );
	}
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down interface list done\n" );
	return( mStatus_NoError );
}

//===========================================================================================================================
//	SetupInterface
//===========================================================================================================================

mDNSlocal mStatus	SetupInterface( mDNS * const inMDNS, const struct ifaddrs *inAddr, MDNSInterfaceItem **outItem )
{
	mStatus							err;
	MDNSInterfaceItem *				item;
	MDNSSocketRef					socketRef;
	const struct sockaddr_in *		ipv4, *mask;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface (name=%s)\n", inAddr->ifa_name );
	check( inMDNS );
	check( inAddr );
	check( inAddr->ifa_addr );
	ipv4 = (const struct sockaddr_in *) inAddr->ifa_addr;
	mask = (const struct sockaddr_in *) inAddr->ifa_netmask;
	check( outItem );
	
	// Allocate memory for the info item.
	
	item = (MDNSInterfaceItem *) calloc( 1, sizeof( *item ) );
	require_action( item, exit, err = mStatus_NoMemoryErr );
	strcpy( item->name, inAddr->ifa_name );
	item->multicastSocketRef	= kInvalidSocketRef;
	item->sendingSocketRef		= kInvalidSocketRef;
	
	// Set up the multicast DNS (port 5353) socket for this interface.
	
	err = SetupSocket( inMDNS, inAddr, MulticastDNSPort, &socketRef );
	require_noerr( err, exit );
	item->multicastSocketRef = socketRef;
		
	// Set up the sending socket for this interface.
	
	err = SetupSocket( inMDNS, inAddr, zeroIPPort, &socketRef );
	require_noerr( err, exit );
	item->sendingSocketRef = socketRef;
	
	// Register this interface with mDNS.
	
	item->hostSet.InterfaceID             = (mDNSInterfaceID) item;
	item->hostSet.ip  .type               = mDNSAddrType_IPv4;
	item->hostSet.ip  .ip.v4.NotAnInteger = ipv4->sin_addr.s_addr;
	item->hostSet.mask.type               = mDNSAddrType_IPv4;
	item->hostSet.mask.ip.v4.NotAnInteger = mask->sin_addr.s_addr;
	item->hostSet.ifname[0]               = 0;
	item->hostSet.Advertise               = inMDNS->AdvertiseLocalAddresses;
	item->hostSet.McastTxRx               = mDNStrue;

	err = mDNS_RegisterInterface( inMDNS, &item->hostSet, mDNSfalse );
	require_noerr( err, exit );
	item->hostRegistered = mDNStrue;
	
	dlog( kDebugLevelInfo, DEBUG_NAME "Registered IP address: %u.%u.%u.%u\n", 
		  item->hostSet.ip.ip.v4.b[ 0 ], item->hostSet.ip.ip.v4.b[ 1 ], 
		  item->hostSet.ip.ip.v4.b[ 2 ], item->hostSet.ip.ip.v4.b[ 3 ] );
	
	// Success!
	
	*outItem = item;
	item = NULL;
	
exit:
	if( item )
	{
		TearDownInterface( inMDNS, item );
	}
	dlog( kDebugLevelVerbose, DEBUG_NAME "setting up interface done (name=%s, err=%ld)\n", inAddr->ifa_name, err );
	return( err );
}

//===========================================================================================================================
//	TearDownInterface
//===========================================================================================================================

mDNSlocal mStatus	TearDownInterface( mDNS * const inMDNS, MDNSInterfaceItem *inItem )
{
	MDNSSocketRef		socketRef;
	
	check( inMDNS );
	check( inItem );
	
	// Deregister this interface with mDNS.
	
	dlog( kDebugLevelInfo, DEBUG_NAME "Deregistering IP address: %u.%u.%u.%u\n", 
		  inItem->hostSet.ip.ip.v4.b[ 0 ], inItem->hostSet.ip.ip.v4.b[ 1 ], 
		  inItem->hostSet.ip.ip.v4.b[ 2 ], inItem->hostSet.ip.ip.v4.b[ 3 ] );
	
	if( inItem->hostRegistered )
	{
		inItem->hostRegistered = mDNSfalse;
		mDNS_DeregisterInterface( inMDNS, &inItem->hostSet, mDNSfalse );
	}
	
	// Close the multicast socket.
	
	socketRef = inItem->multicastSocketRef;
	inItem->multicastSocketRef = kInvalidSocketRef;
	if( socketRef != kInvalidSocketRef )
	{
		dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down multicast socket %d\n", socketRef );
		close( socketRef );
	}
		
	// Close the sending socket.
	
	socketRef = inItem->sendingSocketRef;
	inItem->sendingSocketRef = kInvalidSocketRef;
	if( socketRef != kInvalidSocketRef )
	{
		dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down sending socket %d\n", socketRef );
		close( socketRef );
	}
	
	// Free the memory used by the interface info.
	
	free( inItem );	
	return( mStatus_NoError );
}

//===========================================================================================================================
//	SetupSocket
//===========================================================================================================================

mDNSlocal mStatus
	SetupSocket( 
		mDNS * const 			inMDNS, 
		const struct ifaddrs *	inAddr, 
		mDNSIPPort 				inPort, 
		MDNSSocketRef *			outSocketRef  )
{
	mStatus							err;
	MDNSSocketRef					socketRef;
	int								option;
	unsigned char					optionByte;
	struct ip_mreq					mreq;
	const struct sockaddr_in *		ipv4;
	struct sockaddr_in				addr;
	mDNSv4Addr						ip;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "setting up socket done\n" );
	check( inMDNS );
	check( inAddr );
	check( inAddr->ifa_addr );
	ipv4 = (const struct sockaddr_in *) inAddr->ifa_addr;
	check( outSocketRef );
	
	// Set up a UDP socket for multicast DNS. 
	
	socketRef = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
	require_errno_action( socketRef, errno, exit, err = mStatus_UnknownErr );
		
	// A port of zero means this socket is for sending and should be set up for sending. Otherwise, it is for receiving 
	// and should be set up for receiving. The reason for separate sending vs receiving sockets is to workaround problems
	// with VxWorks IP stack when using dynamic IP configuration such as DHCP (problems binding to wildcard IP when the
	// IP address later changes). Since we have to bind the Multicast DNS address to workaround these issues we have to
	// use a separate sending socket since it is illegal to send a packet with a multicast source address (RFC 1122).
	
	if( inPort.NotAnInteger != zeroIPPort.NotAnInteger )
	{	
		// Turn on reuse port option so multiple servers can listen for Multicast DNS packets.
		
		option = 1;
		err = setsockopt( socketRef, SOL_SOCKET, SO_REUSEADDR, (char *) &option, sizeof( option ) );
		check_errno( err, errno );
		
		// Join the all-DNS multicast group so we receive Multicast DNS packets.
		
		ip.NotAnInteger 			= ipv4->sin_addr.s_addr;
		mreq.imr_multiaddr.s_addr 	= AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
		mreq.imr_interface.s_addr 	= ip.NotAnInteger;
		err = setsockopt( socketRef, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, sizeof( mreq ) );
		check_errno( err, errno );
		
		// Bind to the multicast DNS address and port 5353.
		
		mDNSPlatformMemZero( &addr, sizeof( addr ) );
		addr.sin_family 		= AF_INET;
		addr.sin_port 			= inPort.NotAnInteger;
		addr.sin_addr.s_addr 	= AllDNSLinkGroup_v4.ip.v4.NotAnInteger;
		err = bind( socketRef, (struct sockaddr *) &addr, sizeof( addr ) );
		check_errno( err, errno );
		
		dlog( kDebugLevelVerbose, DEBUG_NAME "setting up socket done (%s, %u.%u.%u.%u:%u, %d)\n", 
			  inAddr->ifa_name, ip.b[ 0 ], ip.b[ 1 ], ip.b[ 2 ], ip.b[ 3 ], ntohs( inPort.NotAnInteger ), socketRef );
	}
	else
	{
		// Bind to the interface address and multicast DNS port.
		
		ip.NotAnInteger 		= ipv4->sin_addr.s_addr;
		mDNSPlatformMemZero( &addr, sizeof( addr ) );
		addr.sin_family 		= AF_INET;
		addr.sin_port 			= MulticastDNSPort.NotAnInteger;
		addr.sin_addr.s_addr 	= ip.NotAnInteger;
		err = bind( socketRef, (struct sockaddr *) &addr, sizeof( addr ) );
		check_errno( err, errno );
		
		// Direct multicast packets to the specified interface.
		
		addr.sin_addr.s_addr = ip.NotAnInteger;
		err = setsockopt( socketRef, IPPROTO_IP, IP_MULTICAST_IF, (char *) &addr.sin_addr, sizeof( addr.sin_addr ) );
		check_errno( err, errno );
		
		// Set the TTL of outgoing unicast packets to 255 (helps against spoofing).
		
		option = 255;
		err = setsockopt( socketRef, IPPROTO_IP, IP_TTL, (char *) &option, sizeof( option ) );
		check_errno( err, errno );
		
		// Set the TTL of outgoing multicast packets to 255 (helps against spoofing).
		
		optionByte = 255;
		err = setsockopt( socketRef, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &optionByte, sizeof( optionByte ) );
		check_errno( err, errno );
		
		// WARNING: Setting this option causes unicast responses to be routed to the wrong interface so they are 
		// WARNING: disabled. These options were only hints to improve 802.11 performance (and not implemented) anyway.
		
#if 0
		// Mark packets as high-throughput/low-delay (i.e. lowest reliability) to maximize 802.11 multicast rate.
		
		option = IPTOS_LOWDELAY | IPTOS_THROUGHPUT;
		err = setsockopt( socketRef, IPPROTO_IP, IP_TOS, (char *) &option, sizeof( option ) );
		check_errno( err, errno );
#endif
	
		dlog( kDebugLevelVerbose, DEBUG_NAME "setting up sending socket done (%s, %u.%u.%u.%u, %d)\n", 
			  inAddr->ifa_name, ip.b[ 0 ], ip.b[ 1 ], ip.b[ 2 ], ip.b[ 3 ], socketRef );
	}
	
	// Success!
	
	*outSocketRef = socketRef;
	socketRef = kInvalidSocketRef;
	err = mStatus_NoError;
	
exit:
	if( socketRef != kInvalidSocketRef )
	{
		close( socketRef );
	}
	return( err );
}

#if 0
#pragma mark -
#pragma mark == Commands ==
#endif

//===========================================================================================================================
//	SetupCommandPipe
//===========================================================================================================================

mDNSlocal mStatus	SetupCommandPipe( mDNS * const inMDNS )
{
	mStatus		err;
	
	// Clean up any leftover command pipe.
	
	TearDownCommandPipe( inMDNS );
	
	// Create the pipe device and open it.
	
	pipeDevCreate( kMDNSPipeName, kMDNSPipeMessageQueueSize, kMDNSPipeMessageSize );
	
	inMDNS->p->commandPipe = open( kMDNSPipeName, O_RDWR, 0 );
	require_errno_action( inMDNS->p->commandPipe, errno, exit, err = mStatus_UnsupportedErr );
	
	err = mStatus_NoError;
	
exit:
	return( err );
}

//===========================================================================================================================
//	TearDownCommandPipe
//===========================================================================================================================

mDNSlocal mStatus	TearDownCommandPipe( mDNS * const inMDNS )
{
	if( inMDNS->p->commandPipe != ERROR )
	{
		close( inMDNS->p->commandPipe );
#ifdef _WRS_VXWORKS_5_X
		// pipeDevDelete is not defined in older versions of VxWorks
		pipeDevDelete( kMDNSPipeName, FALSE );
#endif
		inMDNS->p->commandPipe = ERROR;
	}	
	return( mStatus_NoError );
}

//===========================================================================================================================
//	SendCommand
//===========================================================================================================================

mDNSlocal mStatus	SendCommand( const mDNS * const inMDNS, MDNSPipeCommandCode inCommandCode )
{
	mStatus		err;
	
	require_action( inMDNS->p->commandPipe != ERROR, exit, err = mStatus_NotInitializedErr );
	
	err = write( inMDNS->p->commandPipe, &inCommandCode, sizeof( inCommandCode ) );
	require_errno( err, errno, exit );
	
	err = mStatus_NoError;
	
exit:
	return( err );
}

//===========================================================================================================================
//	ProcessCommand
//===========================================================================================================================

mDNSlocal mStatus	ProcessCommand( mDNS * const inMDNS )
{
	mStatus					err;
	MDNSPipeCommandCode		commandCode;
	
	require_action( inMDNS->p->commandPipe != ERROR, exit, err = mStatus_NotInitializedErr );
	
	// Read the command code from the pipe and dispatch it.
	
	err = read( inMDNS->p->commandPipe, &commandCode, sizeof( commandCode ) );
	require_errno( err, errno, exit );
	
	switch( commandCode )
	{
		case kMDNSPipeCommandCodeReschedule:
			
			// Reschedule event. Do nothing here, but this will cause mDNS_Execute to run before waiting again.
			
			dlog( kDebugLevelChatty, DEBUG_NAME "reschedule\n" );
			break;
		
		case kMDNSPipeCommandCodeReconfigure:
			ProcessCommandReconfigure( inMDNS );
			break;
		
		case kMDNSPipeCommandCodeQuit:
		
			// Quit requested. Set quit flag and bump the config ID to let the thread exit normally.
			
			dlog( kDebugLevelVerbose, DEBUG_NAME "processing pipe quit command\n" );
			inMDNS->p->quit = mDNStrue;
			++inMDNS->p->configID;
			break;
				
		default:
			dlog( kDebugLevelError, DEBUG_NAME "unknown pipe command code (code=0x%08X)\n", commandCode );
			err = mStatus_BadParamErr;
			goto exit;
			break;
	}
	err = mStatus_NoError;

exit:
	return( err );
}

//===========================================================================================================================
//	ProcessCommandReconfigure
//===========================================================================================================================

mDNSlocal void	ProcessCommandReconfigure( mDNS *inMDNS )
{
	mStatus		err;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "processing pipe reconfigure command\n" );
	
	// Tear down the existing interfaces and set up new ones using the new IP info.
	
	mDNSPlatformLock( inMDNS );
	
	err = TearDownInterfaceList( inMDNS );
	check_noerr( err );
	
	err = SetupInterfaceList( inMDNS );
	check_noerr( err );
	
	mDNSPlatformUnlock( inMDNS );
	
	// Inform clients of the change.
	
	mDNS_ConfigChanged(m);
	
	// Force mDNS to update.
	
	mDNSCoreMachineSleep( inMDNS, mDNSfalse ); // What is this for? Mac OS X does not do this
	
	// Bump the config ID so the main processing loop detects the configuration change.
	
	++inMDNS->p->configID;
}

#if 0
#pragma mark -
#pragma mark == Threads ==
#endif

//===========================================================================================================================
//	SetupTask
//===========================================================================================================================

mDNSlocal mStatus	SetupTask( mDNS * const inMDNS )
{
	mStatus		err;
	int			task;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "setting up thread\n" );
	check( inMDNS );
	
	// Create our main thread. Note: The task will save off its ID in the globals. We cannot do it here because the 
	// task invokes code that needs it and the task may begin execution before taskSpawn returns the task ID.
	// This also means code in this thread context cannot rely on the task ID until the task has fully initialized.
	
	task = taskSpawn( kMDNSTaskName, kMDNSTaskPriority, 0, kMDNSTaskStackSize, (FUNCPTR) Task, 
					  (int) inMDNS, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
	require_action( task != ERROR, exit, err = mStatus_NoMemoryErr );
	
	err = mStatus_NoError;
	
exit:
	dlog( kDebugLevelVerbose, DEBUG_NAME "setting up thread done (err=%ld, id=%d)\n", err, task );
	return( err );
}

//===========================================================================================================================
//	TearDownTask
//===========================================================================================================================

mDNSlocal mStatus	TearDownTask( mDNS * const inMDNS )
{
	mStatus		err;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down thread\n" );
	check( inMDNS );
	
	// Send a quit command to cause the thread to exit.
	
	SendCommand( inMDNS, kMDNSPipeCommandCodeQuit );
	
	// Wait for the thread to signal it has exited. Timeout in 10 seconds to handle a hung thread.
	
	if( inMDNS->p->quitEvent )
	{
		err = semTake( inMDNS->p->quitEvent, sysClkRateGet() * 10 );
		check_noerr( err );
	}
	err = mStatus_NoError;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "tearing down thread done (err=%ld)\n", err );
	return( err );
}

//===========================================================================================================================
//	Task
//===========================================================================================================================

mDNSlocal void	Task( mDNS *inMDNS )
{
	mStatus					err;
	fd_set					allReadSet;
	MDNSInterfaceItem *		item;
	int						maxSocket;
	long					configID;
	struct timeval			timeout;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "task starting\n" );
	check( inMDNS );
	
	// Set up everything up.
	
	err = TaskInit( inMDNS );
	require_noerr( err, exit );
	
	// Main Processing Loop.
	
	while( !inMDNS->p->quit )
	{
		// Set up the read set here to avoid the overhead of setting it up each iteration of the main processing loop. 
		// If the configuration changes, the server ID will be bumped, causing this code to set up the read set again.
		
		TaskSetupReadSet( inMDNS, &allReadSet, &maxSocket );
		configID = inMDNS->p->configID;
		dlog( kDebugLevelVerbose, DEBUG_NAME "task starting processing loop (configID=%ld)\n", configID );
		
		while( configID == inMDNS->p->configID )
		{
			mDNSs32		nextTaskTime;
			fd_set		readSet;
			int			n;
			
			// Give the mDNS core a chance to do its work. Reset the rescheduled flag before calling mDNS_Execute
			// so anything that needs processing during or after causes a re-schedule to wake up the thread. The
			// reschedule flag is set to 1 after processing a waking up to prevent redundant reschedules while
			// processing packets. This introduces a window for a race condition because the thread wake-up and
			// reschedule set are not atomic, but this would be benign. Even if the reschedule flag is "corrupted"
			// like this, it would only result in a redundant reschedule since it will loop back to mDNS_Execute.
			
			inMDNS->p->rescheduled = 0;
			nextTaskTime = mDNS_Execute( inMDNS );
			TaskSetupTimeout( inMDNS, nextTaskTime, &timeout );
			
			// Wait until something occurs (e.g. command, incoming packet, or timeout).
			
			readSet = allReadSet;
			n = select( maxSocket + 1, &readSet, NULL, NULL, &timeout );
			inMDNS->p->rescheduled = 1;
			check_errno( n, errno );
			dlog( kDebugLevelChatty - 1, DEBUG_NAME "task select result = %d\n", n );
			if( n == 0 )
			{
				// Next task timeout occurred. Loop back up to give mDNS core a chance to work.
				
				dlog( kDebugLevelChatty, DEBUG_NAME "next task timeout occurred (%ld)\n", mDNS_TimeNow(inMDNS) );
				continue;
			}
			
			// Scan the read set to determine if any sockets have something pending and process them.
			
			n = 0;
			for( item = inMDNS->p->interfaceList; item; item = item->next )
			{
				if( FD_ISSET( item->multicastSocketRef, &readSet ) )
				{
					TaskProcessPacket( inMDNS, item, item->multicastSocketRef );
					++n;
				}
			}
			
			// Check for a pending command and process it.
			
			if( FD_ISSET( inMDNS->p->commandPipe, &readSet ) )
			{
				ProcessCommand( inMDNS );
				++n;
			}
			check( n > 0 );
		}
	}

exit:
	// Signal we've quit.
	
	check( inMDNS->p->quitEvent );
	semGive( inMDNS->p->quitEvent );
	
	dlog( kDebugLevelInfo, DEBUG_NAME "task ended\n" );
}

//===========================================================================================================================
//	TaskInit
//===========================================================================================================================

mDNSlocal mStatus	TaskInit( mDNS *inMDNS )
{
	mStatus		err;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "task init\n" );
	check( inMDNS->p->readyEvent );
	
	inMDNS->p->task = taskIdSelf();
	
	err = SetupCommandPipe( inMDNS );
	require_noerr( err, exit );
	
	SetupNames( inMDNS );
	
	err = SetupInterfaceList( inMDNS );
	require_noerr( err, exit );
	
exit:
	// Signal the "ready" semaphore to indicate the task initialization code has completed (success or not).
	
	inMDNS->p->taskInitErr = err;
	semGive( inMDNS->p->readyEvent );

	dlog( kDebugLevelVerbose, DEBUG_NAME "task init done (err=%ld)\n", err );
	return( err );
}

//===========================================================================================================================
//	TaskSetupReadSet
//===========================================================================================================================

mDNSlocal void	TaskSetupReadSet( mDNS *inMDNS, fd_set *outReadSet, int *outMaxSocket )
{
	MDNSInterfaceItem *		item;
	int						maxSocket;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "task setting up read set\n" );
	check( inMDNS );
	check( outReadSet );
	check( outMaxSocket );
	
	// Initialize the read set. Default the max socket to -1 so "maxSocket + 1" (as needed by select) is zero. This 
	// should never happen since we should always have at least one interface, but it's just to be safe.
	
	FD_ZERO( outReadSet );
	maxSocket = -1;
	
	// Add all the receiving sockets to the read set.
	
	for( item = inMDNS->p->interfaceList; item; item = item->next )
	{
		FD_SET( item->multicastSocketRef, outReadSet );
		if( item->multicastSocketRef > maxSocket )
		{
			maxSocket = item->multicastSocketRef;
		}
	}
	
	// Add the command pipe to the read set.
	
	FD_SET( inMDNS->p->commandPipe, outReadSet );
	if( inMDNS->p->commandPipe > maxSocket )
	{
		maxSocket = inMDNS->p->commandPipe;
	}
	check( maxSocket > 0 );
	*outMaxSocket = maxSocket;
	
	dlog( kDebugLevelVerbose, DEBUG_NAME "task setting up read set done (maxSocket=%d)\n", maxSocket );
}

//===========================================================================================================================
//	TaskSetupTimeout
//===========================================================================================================================

mDNSlocal void	TaskSetupTimeout( mDNS *inMDNS, mDNSs32 inNextTaskTime, struct timeval *outTimeout )
{
	mDNSs32		delta;
	
	// Calculate how long to wait before performing idle processing.
	
	delta = inNextTaskTime - mDNS_TimeNow(inMDNS);
	if( delta <= 0 )
	{
		// The next task time is now or in the past. Set the timeout to fire immediately.
		
		outTimeout->tv_sec 	= 0;
		outTimeout->tv_usec	= 0;
	}
	else
	{
		// Calculate the seconds and microseconds until the timeout should occur. Add one to the ticks remainder 
		// before multiplying to account for integer rounding error and avoid firing the timeout too early.
		
		outTimeout->tv_sec  = delta / mDNSPlatformOneSecond;
		outTimeout->tv_usec = ( ( delta % mDNSPlatformOneSecond ) + 1 ) * gMDNSTicksToMicrosecondsMultiplier;
		
		// Check if the microseconds is more than 1 second. If so, bump the seconds instead.
		
		if( outTimeout->tv_usec >= 1000000L )
		{
			outTimeout->tv_sec += 1;
			outTimeout->tv_usec = 0;
		}
	}
	
	dlog( kDebugLevelChatty, DEBUG_NAME "next task in %ld:%ld seconds (%ld)\n", 
		  outTimeout->tv_sec, outTimeout->tv_usec, inNextTaskTime );
}
//===========================================================================================================================
//	TaskProcessPacket
//===========================================================================================================================

mDNSlocal void	TaskProcessPacket( mDNS *inMDNS, MDNSInterfaceItem *inItem, MDNSSocketRef inSocketRef )
{
	int						n;
	DNSMessage				packet;
	struct sockaddr_in		addr;
	int						addrSize;
	mDNSu8 *				packetEndPtr;
	mDNSAddr				srcAddr;
	mDNSIPPort				srcPort;
	mDNSAddr				dstAddr;
	mDNSIPPort				dstPort;
		
	// Receive the packet.
	
	addrSize = sizeof( addr );
	n = recvfrom( inSocketRef, (char *) &packet, sizeof( packet ), 0, (struct sockaddr *) &addr, &addrSize );
	check( n >= 0 );
	if( n >= 0 )
	{
		// Set up the src/dst/interface info.
		
		srcAddr.type				= mDNSAddrType_IPv4;
		srcAddr.ip.v4.NotAnInteger 	= addr.sin_addr.s_addr;
		srcPort.NotAnInteger		= addr.sin_port;
		dstAddr.type				= mDNSAddrType_IPv4;
		dstAddr.ip.v4				= AllDNSLinkGroup_v4.ip.v4;
		dstPort						= MulticastDNSPort;
		
		dlog( kDebugLevelChatty, DEBUG_NAME "packet received\n" );
		dlog( kDebugLevelChatty, DEBUG_NAME "    size      = %d\n", n );
		dlog( kDebugLevelChatty, DEBUG_NAME "    src       = %u.%u.%u.%u:%hu\n", 
			  srcAddr.ip.v4.b[ 0 ], srcAddr.ip.v4.b[ 1 ], srcAddr.ip.v4.b[ 2 ], srcAddr.ip.v4.b[ 3 ], 
			  ntohs( srcPort.NotAnInteger ) );
		dlog( kDebugLevelChatty, DEBUG_NAME "    dst       = %u.%u.%u.%u:%hu\n", 
			  dstAddr.ip.v4.b[ 0 ], dstAddr.ip.v4.b[ 1 ], dstAddr.ip.v4.b[ 2 ], dstAddr.ip.v4.b[ 3 ], 
			  ntohs( dstPort.NotAnInteger ) );
		dlog( kDebugLevelChatty, DEBUG_NAME "    interface = 0x%08X\n", (int) inItem->hostSet.InterfaceID );
		dlog( kDebugLevelChatty, DEBUG_NAME "--\n" );
		
		// Dispatch the packet to mDNS.
		
		packetEndPtr = ( (mDNSu8 *) &packet ) + n;
		mDNSCoreReceive( inMDNS, &packet, packetEndPtr, &srcAddr, srcPort, &dstAddr, dstPort, inItem->hostSet.InterfaceID );
	}
	
	// Update counters.
	
	inItem->recvCounter			+= 1;
	inItem->recvErrorCounter 	+= ( n < 0 );
}

#if 0
#pragma mark -
#pragma mark == Utilities ==
#endif

#if( TARGET_NON_APPLE )
//===========================================================================================================================
//	GenerateUniqueHostName
//
//	Non-Apple platform stub routine to generate a unique name for the device. Should be implemented to return a unique name.
//===========================================================================================================================

mDNSlocal void	GenerateUniqueHostName( char *outName, long *ioSeed )
{
	DEBUG_UNUSED( ioSeed );
	
	// $$$ Non-Apple Platforms: Fill in appropriate name for device.
	
	mDNSPlatformStrCopy( outName, kMDNSDefaultName );
}

//===========================================================================================================================
//	GenerateUniqueDNSName
//
//	Non-Apple platform stub routine to generate a unique RFC 1034-compatible DNS name for the device. Should be 
//	implemented to return a unique name.
//===========================================================================================================================

mDNSlocal void	GenerateUniqueDNSName( char *outName, long *ioSeed )
{
	DEBUG_UNUSED( ioSeed );
	
	// $$$ Non-Apple Platforms: Fill in appropriate DNS name for device.
	
	mDNSPlatformStrCopy( outName, kMDNSDefaultName );
}
#endif

#if 0
#pragma mark -
#endif

//===========================================================================================================================
//	getifaddrs
//===========================================================================================================================

int	getifaddrs( struct ifaddrs **outAddrs )
{
	int						err;
	struct ifaddrs *		head;
	struct ifaddrs **		next;
	struct ifaddrs *		ifa;
	int						i;
	struct ifnet *			ifp;
	char					ipString[ INET_ADDR_LEN ];
	int						n;
	
	head = NULL;
	next = &head;
	
	i = 1;
	for( ;; )
	{
		ifp = ifIndexToIfp( i );
		if( !ifp )
		{
			break;
		}
		++i;
		
		// Allocate and initialize the ifaddrs structure and attach it to the linked list.
		
		ifa = (struct ifaddrs *) calloc( 1, sizeof( struct ifaddrs ) );
		require_action( ifa, exit, err = ENOMEM );
		
		*next = ifa;
		next  = &ifa->ifa_next;
		
		// Fetch the name.
		
		ifa->ifa_name = (char *) malloc( 16 );
		require_action( ifa->ifa_name, exit, err = ENOMEM );
		
		n = sprintf( ifa->ifa_name, "%s%d", ifp->if_name, ifp->if_unit );
		require_action( n < 16, exit, err = ENOBUFS );
		
		// Fetch the address.
		
		ifa->ifa_addr = (struct sockaddr *) calloc( 1, sizeof( struct sockaddr_in ) );
		require_action( ifa->ifa_addr, exit, err = ENOMEM );
		
		ipString[ 0 ] = '\0';
		#if( TARGET_NON_APPLE )
			err = ifAddrGet( ifa->ifa_name, ipString );
			require_noerr( err, exit );
		#else
			err = ifAddrGetNonAlias( ifa->ifa_name, ipString );
			require_noerr( err, exit );
		#endif
		
		err = sock_pton( ipString, AF_INET, ifa->ifa_addr, 0, NULL );
		require_noerr( err, exit );
		
		// Fetch flags.
		
		ifa->ifa_flags = ifp->if_flags;
	}
	
	// Success!
	
	if( outAddrs )
	{
		*outAddrs = head;
		head = NULL;
	}
	err = 0;

exit:
	if( head )
	{
		freeifaddrs( head );
	}
	return( err );
}

//===========================================================================================================================
//	freeifaddrs
//===========================================================================================================================

void	freeifaddrs( struct ifaddrs *inAddrs )
{
	struct ifaddrs *		p;
	struct ifaddrs *		q;
	
	// Free each piece of the structure. Set to null after freeing to handle macro-aliased fields.
	
	for( p = inAddrs; p; p = q )
	{
		q = p->ifa_next;
		
		if( p->ifa_name )
		{
			free( p->ifa_name );
			p->ifa_name = NULL;
		}
		if( p->ifa_addr )
		{
			free( p->ifa_addr );
			p->ifa_addr = NULL;
		}
		if( p->ifa_netmask )
		{
			free( p->ifa_netmask );
			p->ifa_netmask = NULL;
		}
		if( p->ifa_dstaddr )
		{
			free( p->ifa_dstaddr );
			p->ifa_dstaddr = NULL;
		}
		if( p->ifa_data )
		{
			free( p->ifa_data );
			p->ifa_data = NULL;
		}
		free( p );
	}
}

//===========================================================================================================================
//	sock_pton
//===========================================================================================================================

int	sock_pton( const char *inString, int inFamily, void *outAddr, size_t inAddrSize, size_t *outAddrSize )
{
	int		err;
	
	if( inFamily == AF_INET )
	{
		struct sockaddr_in *		ipv4;
		
		if( inAddrSize == 0 )
		{
			inAddrSize = sizeof( struct sockaddr_in );
		}
		if( inAddrSize < sizeof( struct sockaddr_in ) )
		{
			err = EINVAL;
			goto exit;
		}
		
		ipv4 = (struct sockaddr_in *) outAddr;
		err = inet_aton( (char *) inString, &ipv4->sin_addr );
		if( err == 0 )
		{
			ipv4->sin_family = AF_INET;
			if( outAddrSize )
			{
				*outAddrSize = sizeof( struct sockaddr_in );
			}
		}
	}
#if( defined( AF_INET6 ) )
	else if( inFamily == AF_INET6 )		// $$$ TO DO: Add IPv6 support.
	{
		err = EAFNOSUPPORT;
		goto exit;
	}
#endif
	else
	{
		err = EAFNOSUPPORT;
		goto exit;
	}

exit:
	return( err );
}

//===========================================================================================================================
//	sock_ntop
//===========================================================================================================================

char *	sock_ntop( const void *inAddr, size_t inAddrSize, char *inBuffer, size_t inBufferSize )
{
	const struct sockaddr *		addr;
	
	addr = (const struct sockaddr *) inAddr;
	if( addr->sa_family == AF_INET )
	{
		struct sockaddr_in *		ipv4;
		
		if( inAddrSize == 0 )
		{
			inAddrSize = sizeof( struct sockaddr_in );
		}
		if( inAddrSize < sizeof( struct sockaddr_in ) )
		{
			errno = EINVAL;
			inBuffer = NULL;
			goto exit;
		}
		if( inBufferSize < 16 )
		{
			errno = ENOBUFS;
			inBuffer = NULL;
			goto exit;
		}
		
		ipv4 = (struct sockaddr_in *) addr;
		inet_ntoa_b( ipv4->sin_addr, inBuffer );
	}
#if( defined( AF_INET6 ) )
	else if( addr->sa_family == AF_INET6 )	// $$$ TO DO: Add IPv6 support.
	{		
		errno = EAFNOSUPPORT;
		inBuffer = NULL;
		goto exit;
	}
#endif
	else
	{
		errno = EAFNOSUPPORT;
		inBuffer = NULL;
		goto exit;
	}
	
exit:
	return( inBuffer );
}

#if 0
#pragma mark -
#pragma mark == Debugging ==
#endif

#if( DEBUG )

void	mDNSShow( BOOL inShowRecords );
void	mDNSShowRecords( void );
void	mDNSShowTXT( const void *inTXT, size_t inTXTSize );

//===========================================================================================================================
//	mDNSShow
//===========================================================================================================================

void	mDNSShow( BOOL inShowRecords )
{
	MDNSInterfaceItem *		item;
	mDNSAddr				ip;
	int						n;
	
	if( !gMDNSPtr )
	{
		printf( "### mDNS not initialized\n" );
		return;
	}
	
	// Globals
	
	printf( "\n-- mDNS globals --\n" );
	printf( "    sizeof( mDNS )                     = %d\n", (int) sizeof( mDNS ) );
	printf( "    sizeof( ResourceRecord )           = %d\n", (int) sizeof( ResourceRecord ) );
	printf( "    sizeof( AuthRecord )               = %d\n", (int) sizeof( AuthRecord ) );
	printf( "    sizeof( CacheRecord )              = %d\n", (int) sizeof( CacheRecord ) );
	printf( "    gMDNSPtr                           = 0x%08lX\n", (unsigned long) gMDNSPtr );
	printf( "    gMDNSTicksToMicrosecondsMultiplier = %ld\n", gMDNSTicksToMicrosecondsMultiplier );
	printf( "    lockID                             = 0x%08lX\n", (unsigned long) gMDNSPtr->p->lockID );
	printf( "    readyEvent                         = 0x%08lX\n", (unsigned long) gMDNSPtr->p->readyEvent );
	printf( "    taskInitErr                        = %ld\n", gMDNSPtr->p->taskInitErr );
	printf( "    quitEvent                          = 0x%08lX\n", (unsigned long) gMDNSPtr->p->quitEvent );
	printf( "    commandPipe                        = %d\n", gMDNSPtr->p->commandPipe );
	printf( "    task                               = 0x%08lX\n", (unsigned long) gMDNSPtr->p->task );
	printf( "    quit                               = %d\n", gMDNSPtr->p->quit );
	printf( "    configID                           = %ld\n", gMDNSPtr->p->configID );
	printf( "    rescheduled                        = %d\n", gMDNSPtr->p->rescheduled );
	printf( "    nicelabel                          = \"%.*s\"\n", gMDNSPtr->nicelabel.c[ 0 ], (char *) &gMDNSPtr->nicelabel.c[ 1 ] );
	printf( "    hostLabel                          = \"%.*s\"\n", gMDNSPtr->hostlabel.c[ 0 ], (char *) &gMDNSPtr->hostlabel.c[ 1 ] );
	printf( "\n");
	
	// Interfaces
	
	printf( "\n-- mDNS interfaces --\n" );
	n = 1;
	for( item = gMDNSPtr->p->interfaceList; item; item = item->next )
	{
		printf( "    -- interface %u --\n", n );
		printf( "        name                           = \"%s\"\n", item->name );
		printf( "        multicastSocketRef             = %d\n", item->multicastSocketRef );
		printf( "        sendingSocketRef               = %d\n", item->sendingSocketRef );
		ip = item->hostSet.ip;
		printf( "        hostSet.ip                     = %u.%u.%u.%u\n", ip.ip.v4.b[ 0 ], ip.ip.v4.b[ 1 ], 
																		  ip.ip.v4.b[ 2 ], ip.ip.v4.b[ 3 ] );
		printf( "        hostSet.advertise              = %s\n", item->hostSet.Advertise ? "YES" : "NO" );
		printf( "        hostRegistered                 = %s\n", item->hostRegistered ? "YES" : "NO" );
		printf( "        --\n" );
		printf( "        sendMulticastCounter           = %d\n", item->sendMulticastCounter );
		printf( "        sendUnicastCounter             = %d\n", item->sendUnicastCounter );
		printf( "        sendErrorCounter               = %d\n", item->sendErrorCounter );
		printf( "        recvCounter                    = %d\n", item->recvCounter );
		printf( "        recvErrorCounter               = %d\n", item->recvErrorCounter );
		printf( "        recvLoopCounter                = %d\n", item->recvLoopCounter );
		printf( "\n" );
		++n;
	}
	
	// Resource Records
	
	if( inShowRecords )
	{
		mDNSShowRecords();
	}
}

//===========================================================================================================================
//	mDNSShowRecords
//===========================================================================================================================

void	mDNSShowRecords( void )
{
	MDNSInterfaceItem *		item;
	int						n;
	AuthRecord *			record;
	char					name[ MAX_ESCAPED_DOMAIN_NAME ];
	
	printf( "\n-- mDNS resource records --\n" );
	n = 1;
	for( record = gMDNSPtr->ResourceRecords; record; record = record->next )
	{
		item = (MDNSInterfaceItem *) record->resrec.InterfaceID;
		ConvertDomainNameToCString( &record->resrec.name, name );
		printf( "    -- record %d --\n", n );
		printf( "        interface = 0x%08X (%s)\n", (int) item, item ? item->name : "<any>" );
		printf( "        name      = \"%s\"\n", name );
		printf( "\n" );
		++n;
	}
	printf( "\n");
}

//===========================================================================================================================
//	mDNSShowTXT
//===========================================================================================================================

void	mDNSShowTXT( const void *inTXT, size_t inTXTSize )
{
	const mDNSu8 *		p;
	const mDNSu8 *		end;
	int					i;
	mDNSu8				size;
	
	printf( "\nTXT record (%u bytes):\n\n", inTXTSize );
	
	p 	= (const mDNSu8 *) inTXT;
	end = p + inTXTSize;
	i 	= 0;
	
	while( p < end )
	{
		size = *p++;
		if( ( p + size ) > end )
		{
			printf( "\n### MALFORMED TXT RECORD (length byte too big for record)\n\n" );
			break;
		}
		printf( "%2d (%3d bytes): \"%.*s\"\n", i, size, size, p );
		p += size;
		++i;
	}
	printf( "\n" );
}
#endif	// DEBUG
